/*
 * XML Type:  XArea
 * Namespace: http://www.seedwill.com/xul/widget/
 * Java type: com.seedwill.xul.widget.XArea
 *
 * Automatically generated - do not modify.
 */
package com.seedwill.xul.widget.impl;
/**
 * An XML XArea(@http://www.seedwill.com/xul/widget/).
 *
 * This is a complex type.
 */
public class XAreaImpl extends com.seedwill.xul.core.impl.XIdentifiedImpl implements com.seedwill.xul.widget.XArea
{
    private static final long serialVersionUID = 1L;
    
    public XAreaImpl(org.apache.xmlbeans.SchemaType sType)
    {
        super(sType);
    }
    
    private static final javax.xml.namespace.QName TYPE$0 = 
        new javax.xml.namespace.QName("", "type");
    private static final javax.xml.namespace.QName SORT$2 = 
        new javax.xml.namespace.QName("", "sort");
    private static final javax.xml.namespace.QName ALIGN$4 = 
        new javax.xml.namespace.QName("", "align");
    private static final javax.xml.namespace.QName MODE$6 = 
        new javax.xml.namespace.QName("", "mode");
    private static final javax.xml.namespace.QName LAYOUT$8 = 
        new javax.xml.namespace.QName("", "layout");
    private static final javax.xml.namespace.QName LABEL$10 = 
        new javax.xml.namespace.QName("", "label");
    private static final javax.xml.namespace.QName INPUTS$12 = 
        new javax.xml.namespace.QName("", "inputs");
    private static final javax.xml.namespace.QName BUTTONS$14 = 
        new javax.xml.namespace.QName("", "buttons");
    private static final javax.xml.namespace.QName CHILDREN$16 = 
        new javax.xml.namespace.QName("", "children");
    private static final javax.xml.namespace.QName INPUTUNITS$18 = 
        new javax.xml.namespace.QName("", "inputUnits");
    private static final javax.xml.namespace.QName CATEGORY$20 = 
        new javax.xml.namespace.QName("", "category");
    private static final javax.xml.namespace.QName ABSSIZE$22 = 
        new javax.xml.namespace.QName("", "absSize");
    private static final javax.xml.namespace.QName ABSLOCATION$24 = 
        new javax.xml.namespace.QName("", "absLocation");
    private static final javax.xml.namespace.QName LAYOUTDATA$26 = 
        new javax.xml.namespace.QName("", "layoutData");
    private static final javax.xml.namespace.QName FORMID$28 = 
        new javax.xml.namespace.QName("", "formId");
    
    
    /**
     * Gets the "type" element
     */
    public java.lang.String getType()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(TYPE$0, 0);
            if (target == null)
            {
                return null;
            }
            return target.getStringValue();
        }
    }
    
    /**
     * Gets (as xml) the "type" element
     */
    public org.apache.xmlbeans.XmlString xgetType()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.XmlString target = null;
            target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(TYPE$0, 0);
            return target;
        }
    }
    
    /**
     * Sets the "type" element
     */
    public void setType(java.lang.String type)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(TYPE$0, 0);
            if (target == null)
            {
                target = (org.apache.xmlbeans.SimpleValue)get_store().add_element_user(TYPE$0);
            }
            target.setStringValue(type);
        }
    }
    
    /**
     * Sets (as xml) the "type" element
     */
    public void xsetType(org.apache.xmlbeans.XmlString type)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.XmlString target = null;
            target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(TYPE$0, 0);
            if (target == null)
            {
                target = (org.apache.xmlbeans.XmlString)get_store().add_element_user(TYPE$0);
            }
            target.set(type);
        }
    }
    
    /**
     * Gets the "sort" element
     */
    public int getSort()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(SORT$2, 0);
            if (target == null)
            {
                return 0;
            }
            return target.getIntValue();
        }
    }
    
    /**
     * Gets (as xml) the "sort" element
     */
    public org.apache.xmlbeans.XmlInt xgetSort()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.XmlInt target = null;
            target = (org.apache.xmlbeans.XmlInt)get_store().find_element_user(SORT$2, 0);
            return target;
        }
    }
    
    /**
     * True if has "sort" element
     */
    public boolean isSetSort()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(SORT$2) != 0;
        }
    }
    
    /**
     * Sets the "sort" element
     */
    public void setSort(int sort)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(SORT$2, 0);
            if (target == null)
            {
                target = (org.apache.xmlbeans.SimpleValue)get_store().add_element_user(SORT$2);
            }
            target.setIntValue(sort);
        }
    }
    
    /**
     * Sets (as xml) the "sort" element
     */
    public void xsetSort(org.apache.xmlbeans.XmlInt sort)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.XmlInt target = null;
            target = (org.apache.xmlbeans.XmlInt)get_store().find_element_user(SORT$2, 0);
            if (target == null)
            {
                target = (org.apache.xmlbeans.XmlInt)get_store().add_element_user(SORT$2);
            }
            target.set(sort);
        }
    }
    
    /**
     * Unsets the "sort" element
     */
    public void unsetSort()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(SORT$2, 0);
        }
    }
    
    /**
     * Gets the "align" element
     */
    public com.seedwill.xul.core.XCellAlign.Enum getAlign()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ALIGN$4, 0);
            if (target == null)
            {
                return null;
            }
            return (com.seedwill.xul.core.XCellAlign.Enum)target.getEnumValue();
        }
    }
    
    /**
     * Gets (as xml) the "align" element
     */
    public com.seedwill.xul.core.XCellAlign xgetAlign()
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.core.XCellAlign target = null;
            target = (com.seedwill.xul.core.XCellAlign)get_store().find_element_user(ALIGN$4, 0);
            return target;
        }
    }
    
    /**
     * True if has "align" element
     */
    public boolean isSetAlign()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(ALIGN$4) != 0;
        }
    }
    
    /**
     * Sets the "align" element
     */
    public void setAlign(com.seedwill.xul.core.XCellAlign.Enum align)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(ALIGN$4, 0);
            if (target == null)
            {
                target = (org.apache.xmlbeans.SimpleValue)get_store().add_element_user(ALIGN$4);
            }
            target.setEnumValue(align);
        }
    }
    
    /**
     * Sets (as xml) the "align" element
     */
    public void xsetAlign(com.seedwill.xul.core.XCellAlign align)
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.core.XCellAlign target = null;
            target = (com.seedwill.xul.core.XCellAlign)get_store().find_element_user(ALIGN$4, 0);
            if (target == null)
            {
                target = (com.seedwill.xul.core.XCellAlign)get_store().add_element_user(ALIGN$4);
            }
            target.set(align);
        }
    }
    
    /**
     * Unsets the "align" element
     */
    public void unsetAlign()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(ALIGN$4, 0);
        }
    }
    
    /**
     * Gets the "mode" element
     */
    public com.seedwill.xul.core.XAreaMode.Enum getMode()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(MODE$6, 0);
            if (target == null)
            {
                return null;
            }
            return (com.seedwill.xul.core.XAreaMode.Enum)target.getEnumValue();
        }
    }
    
    /**
     * Gets (as xml) the "mode" element
     */
    public com.seedwill.xul.core.XAreaMode xgetMode()
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.core.XAreaMode target = null;
            target = (com.seedwill.xul.core.XAreaMode)get_store().find_element_user(MODE$6, 0);
            return target;
        }
    }
    
    /**
     * True if has "mode" element
     */
    public boolean isSetMode()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(MODE$6) != 0;
        }
    }
    
    /**
     * Sets the "mode" element
     */
    public void setMode(com.seedwill.xul.core.XAreaMode.Enum mode)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(MODE$6, 0);
            if (target == null)
            {
                target = (org.apache.xmlbeans.SimpleValue)get_store().add_element_user(MODE$6);
            }
            target.setEnumValue(mode);
        }
    }
    
    /**
     * Sets (as xml) the "mode" element
     */
    public void xsetMode(com.seedwill.xul.core.XAreaMode mode)
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.core.XAreaMode target = null;
            target = (com.seedwill.xul.core.XAreaMode)get_store().find_element_user(MODE$6, 0);
            if (target == null)
            {
                target = (com.seedwill.xul.core.XAreaMode)get_store().add_element_user(MODE$6);
            }
            target.set(mode);
        }
    }
    
    /**
     * Unsets the "mode" element
     */
    public void unsetMode()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(MODE$6, 0);
        }
    }
    
    /**
     * Gets the "layout" element
     */
    public com.seedwill.xul.core.XTableLayout getLayout()
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.core.XTableLayout target = null;
            target = (com.seedwill.xul.core.XTableLayout)get_store().find_element_user(LAYOUT$8, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "layout" element
     */
    public boolean isSetLayout()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(LAYOUT$8) != 0;
        }
    }
    
    /**
     * Sets the "layout" element
     */
    public void setLayout(com.seedwill.xul.core.XTableLayout layout)
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.core.XTableLayout target = null;
            target = (com.seedwill.xul.core.XTableLayout)get_store().find_element_user(LAYOUT$8, 0);
            if (target == null)
            {
                target = (com.seedwill.xul.core.XTableLayout)get_store().add_element_user(LAYOUT$8);
            }
            target.set(layout);
        }
    }
    
    /**
     * Appends and returns a new empty "layout" element
     */
    public com.seedwill.xul.core.XTableLayout addNewLayout()
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.core.XTableLayout target = null;
            target = (com.seedwill.xul.core.XTableLayout)get_store().add_element_user(LAYOUT$8);
            return target;
        }
    }
    
    /**
     * Unsets the "layout" element
     */
    public void unsetLayout()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(LAYOUT$8, 0);
        }
    }
    
    /**
     * Gets the "label" element
     */
    public com.seedwill.xul.widget.XLabel getLabel()
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.widget.XLabel target = null;
            target = (com.seedwill.xul.widget.XLabel)get_store().find_element_user(LABEL$10, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "label" element
     */
    public boolean isSetLabel()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(LABEL$10) != 0;
        }
    }
    
    /**
     * Sets the "label" element
     */
    public void setLabel(com.seedwill.xul.widget.XLabel label)
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.widget.XLabel target = null;
            target = (com.seedwill.xul.widget.XLabel)get_store().find_element_user(LABEL$10, 0);
            if (target == null)
            {
                target = (com.seedwill.xul.widget.XLabel)get_store().add_element_user(LABEL$10);
            }
            target.set(label);
        }
    }
    
    /**
     * Appends and returns a new empty "label" element
     */
    public com.seedwill.xul.widget.XLabel addNewLabel()
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.widget.XLabel target = null;
            target = (com.seedwill.xul.widget.XLabel)get_store().add_element_user(LABEL$10);
            return target;
        }
    }
    
    /**
     * Unsets the "label" element
     */
    public void unsetLabel()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(LABEL$10, 0);
        }
    }
    
    /**
     * Gets array of all "inputs" elements
     */
    public com.seedwill.xul.widget.XInput[] getInputsArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(INPUTS$12, targetList);
            com.seedwill.xul.widget.XInput[] result = new com.seedwill.xul.widget.XInput[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "inputs" element
     */
    public com.seedwill.xul.widget.XInput getInputsArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.widget.XInput target = null;
            target = (com.seedwill.xul.widget.XInput)get_store().find_element_user(INPUTS$12, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "inputs" element
     */
    public int sizeOfInputsArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(INPUTS$12);
        }
    }
    
    /**
     * Sets array of all "inputs" element
     */
    public void setInputsArray(com.seedwill.xul.widget.XInput[] inputsArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(inputsArray, INPUTS$12);
        }
    }
    
    /**
     * Sets ith "inputs" element
     */
    public void setInputsArray(int i, com.seedwill.xul.widget.XInput inputs)
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.widget.XInput target = null;
            target = (com.seedwill.xul.widget.XInput)get_store().find_element_user(INPUTS$12, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(inputs);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "inputs" element
     */
    public com.seedwill.xul.widget.XInput insertNewInputs(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.widget.XInput target = null;
            target = (com.seedwill.xul.widget.XInput)get_store().insert_element_user(INPUTS$12, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "inputs" element
     */
    public com.seedwill.xul.widget.XInput addNewInputs()
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.widget.XInput target = null;
            target = (com.seedwill.xul.widget.XInput)get_store().add_element_user(INPUTS$12);
            return target;
        }
    }
    
    /**
     * Removes the ith "inputs" element
     */
    public void removeInputs(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(INPUTS$12, i);
        }
    }
    
    /**
     * Gets array of all "buttons" elements
     */
    public com.seedwill.xul.widget.XButton[] getButtonsArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(BUTTONS$14, targetList);
            com.seedwill.xul.widget.XButton[] result = new com.seedwill.xul.widget.XButton[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "buttons" element
     */
    public com.seedwill.xul.widget.XButton getButtonsArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.widget.XButton target = null;
            target = (com.seedwill.xul.widget.XButton)get_store().find_element_user(BUTTONS$14, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "buttons" element
     */
    public int sizeOfButtonsArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(BUTTONS$14);
        }
    }
    
    /**
     * Sets array of all "buttons" element
     */
    public void setButtonsArray(com.seedwill.xul.widget.XButton[] buttonsArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(buttonsArray, BUTTONS$14);
        }
    }
    
    /**
     * Sets ith "buttons" element
     */
    public void setButtonsArray(int i, com.seedwill.xul.widget.XButton buttons)
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.widget.XButton target = null;
            target = (com.seedwill.xul.widget.XButton)get_store().find_element_user(BUTTONS$14, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(buttons);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "buttons" element
     */
    public com.seedwill.xul.widget.XButton insertNewButtons(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.widget.XButton target = null;
            target = (com.seedwill.xul.widget.XButton)get_store().insert_element_user(BUTTONS$14, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "buttons" element
     */
    public com.seedwill.xul.widget.XButton addNewButtons()
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.widget.XButton target = null;
            target = (com.seedwill.xul.widget.XButton)get_store().add_element_user(BUTTONS$14);
            return target;
        }
    }
    
    /**
     * Removes the ith "buttons" element
     */
    public void removeButtons(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(BUTTONS$14, i);
        }
    }
    
    /**
     * Gets array of all "children" elements
     */
    public com.seedwill.xul.widget.XArea[] getChildrenArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(CHILDREN$16, targetList);
            com.seedwill.xul.widget.XArea[] result = new com.seedwill.xul.widget.XArea[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "children" element
     */
    public com.seedwill.xul.widget.XArea getChildrenArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.widget.XArea target = null;
            target = (com.seedwill.xul.widget.XArea)get_store().find_element_user(CHILDREN$16, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "children" element
     */
    public int sizeOfChildrenArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(CHILDREN$16);
        }
    }
    
    /**
     * Sets array of all "children" element
     */
    public void setChildrenArray(com.seedwill.xul.widget.XArea[] childrenArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(childrenArray, CHILDREN$16);
        }
    }
    
    /**
     * Sets ith "children" element
     */
    public void setChildrenArray(int i, com.seedwill.xul.widget.XArea children)
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.widget.XArea target = null;
            target = (com.seedwill.xul.widget.XArea)get_store().find_element_user(CHILDREN$16, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(children);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "children" element
     */
    public com.seedwill.xul.widget.XArea insertNewChildren(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.widget.XArea target = null;
            target = (com.seedwill.xul.widget.XArea)get_store().insert_element_user(CHILDREN$16, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "children" element
     */
    public com.seedwill.xul.widget.XArea addNewChildren()
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.widget.XArea target = null;
            target = (com.seedwill.xul.widget.XArea)get_store().add_element_user(CHILDREN$16);
            return target;
        }
    }
    
    /**
     * Removes the ith "children" element
     */
    public void removeChildren(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(CHILDREN$16, i);
        }
    }
    
    /**
     * Gets array of all "inputUnits" elements
     */
    public com.seedwill.xul.widget.XInputUnit[] getInputUnitsArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(INPUTUNITS$18, targetList);
            com.seedwill.xul.widget.XInputUnit[] result = new com.seedwill.xul.widget.XInputUnit[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "inputUnits" element
     */
    public com.seedwill.xul.widget.XInputUnit getInputUnitsArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.widget.XInputUnit target = null;
            target = (com.seedwill.xul.widget.XInputUnit)get_store().find_element_user(INPUTUNITS$18, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "inputUnits" element
     */
    public int sizeOfInputUnitsArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(INPUTUNITS$18);
        }
    }
    
    /**
     * Sets array of all "inputUnits" element
     */
    public void setInputUnitsArray(com.seedwill.xul.widget.XInputUnit[] inputUnitsArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(inputUnitsArray, INPUTUNITS$18);
        }
    }
    
    /**
     * Sets ith "inputUnits" element
     */
    public void setInputUnitsArray(int i, com.seedwill.xul.widget.XInputUnit inputUnits)
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.widget.XInputUnit target = null;
            target = (com.seedwill.xul.widget.XInputUnit)get_store().find_element_user(INPUTUNITS$18, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(inputUnits);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "inputUnits" element
     */
    public com.seedwill.xul.widget.XInputUnit insertNewInputUnits(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.widget.XInputUnit target = null;
            target = (com.seedwill.xul.widget.XInputUnit)get_store().insert_element_user(INPUTUNITS$18, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "inputUnits" element
     */
    public com.seedwill.xul.widget.XInputUnit addNewInputUnits()
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.widget.XInputUnit target = null;
            target = (com.seedwill.xul.widget.XInputUnit)get_store().add_element_user(INPUTUNITS$18);
            return target;
        }
    }
    
    /**
     * Removes the ith "inputUnits" element
     */
    public void removeInputUnits(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(INPUTUNITS$18, i);
        }
    }
    
    /**
     * Gets the "category" element
     */
    public com.seedwill.xul.widget.XAreaCategoryType.Enum getCategory()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(CATEGORY$20, 0);
            if (target == null)
            {
                return null;
            }
            return (com.seedwill.xul.widget.XAreaCategoryType.Enum)target.getEnumValue();
        }
    }
    
    /**
     * Gets (as xml) the "category" element
     */
    public com.seedwill.xul.widget.XAreaCategoryType xgetCategory()
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.widget.XAreaCategoryType target = null;
            target = (com.seedwill.xul.widget.XAreaCategoryType)get_store().find_element_user(CATEGORY$20, 0);
            return target;
        }
    }
    
    /**
     * True if has "category" element
     */
    public boolean isSetCategory()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(CATEGORY$20) != 0;
        }
    }
    
    /**
     * Sets the "category" element
     */
    public void setCategory(com.seedwill.xul.widget.XAreaCategoryType.Enum category)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(CATEGORY$20, 0);
            if (target == null)
            {
                target = (org.apache.xmlbeans.SimpleValue)get_store().add_element_user(CATEGORY$20);
            }
            target.setEnumValue(category);
        }
    }
    
    /**
     * Sets (as xml) the "category" element
     */
    public void xsetCategory(com.seedwill.xul.widget.XAreaCategoryType category)
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.widget.XAreaCategoryType target = null;
            target = (com.seedwill.xul.widget.XAreaCategoryType)get_store().find_element_user(CATEGORY$20, 0);
            if (target == null)
            {
                target = (com.seedwill.xul.widget.XAreaCategoryType)get_store().add_element_user(CATEGORY$20);
            }
            target.set(category);
        }
    }
    
    /**
     * Unsets the "category" element
     */
    public void unsetCategory()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(CATEGORY$20, 0);
        }
    }
    
    /**
     * Gets the "absSize" element
     */
    public com.seedwill.xul.core.XSize getAbsSize()
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.core.XSize target = null;
            target = (com.seedwill.xul.core.XSize)get_store().find_element_user(ABSSIZE$22, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "absSize" element
     */
    public boolean isSetAbsSize()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(ABSSIZE$22) != 0;
        }
    }
    
    /**
     * Sets the "absSize" element
     */
    public void setAbsSize(com.seedwill.xul.core.XSize absSize)
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.core.XSize target = null;
            target = (com.seedwill.xul.core.XSize)get_store().find_element_user(ABSSIZE$22, 0);
            if (target == null)
            {
                target = (com.seedwill.xul.core.XSize)get_store().add_element_user(ABSSIZE$22);
            }
            target.set(absSize);
        }
    }
    
    /**
     * Appends and returns a new empty "absSize" element
     */
    public com.seedwill.xul.core.XSize addNewAbsSize()
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.core.XSize target = null;
            target = (com.seedwill.xul.core.XSize)get_store().add_element_user(ABSSIZE$22);
            return target;
        }
    }
    
    /**
     * Unsets the "absSize" element
     */
    public void unsetAbsSize()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(ABSSIZE$22, 0);
        }
    }
    
    /**
     * Gets the "absLocation" element
     */
    public com.seedwill.xul.core.XLocation getAbsLocation()
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.core.XLocation target = null;
            target = (com.seedwill.xul.core.XLocation)get_store().find_element_user(ABSLOCATION$24, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "absLocation" element
     */
    public boolean isSetAbsLocation()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(ABSLOCATION$24) != 0;
        }
    }
    
    /**
     * Sets the "absLocation" element
     */
    public void setAbsLocation(com.seedwill.xul.core.XLocation absLocation)
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.core.XLocation target = null;
            target = (com.seedwill.xul.core.XLocation)get_store().find_element_user(ABSLOCATION$24, 0);
            if (target == null)
            {
                target = (com.seedwill.xul.core.XLocation)get_store().add_element_user(ABSLOCATION$24);
            }
            target.set(absLocation);
        }
    }
    
    /**
     * Appends and returns a new empty "absLocation" element
     */
    public com.seedwill.xul.core.XLocation addNewAbsLocation()
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.core.XLocation target = null;
            target = (com.seedwill.xul.core.XLocation)get_store().add_element_user(ABSLOCATION$24);
            return target;
        }
    }
    
    /**
     * Unsets the "absLocation" element
     */
    public void unsetAbsLocation()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(ABSLOCATION$24, 0);
        }
    }
    
    /**
     * Gets the "layoutData" element
     */
    public com.seedwill.xul.core.XGridLayoutData getLayoutData()
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.core.XGridLayoutData target = null;
            target = (com.seedwill.xul.core.XGridLayoutData)get_store().find_element_user(LAYOUTDATA$26, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "layoutData" element
     */
    public boolean isSetLayoutData()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(LAYOUTDATA$26) != 0;
        }
    }
    
    /**
     * Sets the "layoutData" element
     */
    public void setLayoutData(com.seedwill.xul.core.XGridLayoutData layoutData)
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.core.XGridLayoutData target = null;
            target = (com.seedwill.xul.core.XGridLayoutData)get_store().find_element_user(LAYOUTDATA$26, 0);
            if (target == null)
            {
                target = (com.seedwill.xul.core.XGridLayoutData)get_store().add_element_user(LAYOUTDATA$26);
            }
            target.set(layoutData);
        }
    }
    
    /**
     * Appends and returns a new empty "layoutData" element
     */
    public com.seedwill.xul.core.XGridLayoutData addNewLayoutData()
    {
        synchronized (monitor())
        {
            check_orphaned();
            com.seedwill.xul.core.XGridLayoutData target = null;
            target = (com.seedwill.xul.core.XGridLayoutData)get_store().add_element_user(LAYOUTDATA$26);
            return target;
        }
    }
    
    /**
     * Unsets the "layoutData" element
     */
    public void unsetLayoutData()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(LAYOUTDATA$26, 0);
        }
    }
    
    /**
     * Gets the "formId" element
     */
    public java.lang.String getFormId()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(FORMID$28, 0);
            if (target == null)
            {
                return null;
            }
            return target.getStringValue();
        }
    }
    
    /**
     * Gets (as xml) the "formId" element
     */
    public org.apache.xmlbeans.XmlString xgetFormId()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.XmlString target = null;
            target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(FORMID$28, 0);
            return target;
        }
    }
    
    /**
     * True if has "formId" element
     */
    public boolean isSetFormId()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(FORMID$28) != 0;
        }
    }
    
    /**
     * Sets the "formId" element
     */
    public void setFormId(java.lang.String formId)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_element_user(FORMID$28, 0);
            if (target == null)
            {
                target = (org.apache.xmlbeans.SimpleValue)get_store().add_element_user(FORMID$28);
            }
            target.setStringValue(formId);
        }
    }
    
    /**
     * Sets (as xml) the "formId" element
     */
    public void xsetFormId(org.apache.xmlbeans.XmlString formId)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.XmlString target = null;
            target = (org.apache.xmlbeans.XmlString)get_store().find_element_user(FORMID$28, 0);
            if (target == null)
            {
                target = (org.apache.xmlbeans.XmlString)get_store().add_element_user(FORMID$28);
            }
            target.set(formId);
        }
    }
    
    /**
     * Unsets the "formId" element
     */
    public void unsetFormId()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(FORMID$28, 0);
        }
    }
}
